package org.apache.lucene.queryParser;

/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import org.apache.lucene.analysis.Analyzer;
import org.apache.lucene.search.BooleanClause;
import org.apache.lucene.search.BooleanQuery;
import org.apache.lucene.search.MultiPhraseQuery;
import org.apache.lucene.search.PhraseQuery;
import org.apache.lucene.search.Query;

import java.util.Vector;
import java.util.Map;

/**
 * A QueryParser which constructs queries to search multiple fields.
 * 
 * 
 * @version $Revision: 564236 $
 */
public class MultiFieldQueryParser extends QueryParser {
	protected String[] fields;
	protected Map boosts;

	/**
	 * Creates a MultiFieldQueryParser. Allows passing of a map with term to
	 * Boost, and the boost to apply to each term.
	 * 
	 * <p>
	 * It will, when parse(String query) is called, construct a query like this
	 * (assuming the query consists of two terms and you specify the two fields
	 * <code>title</code> and <code>body</code>):
	 * </p>
	 * 
	 * <code>
	 * (title:term1 body:term1) (title:term2 body:term2)
	 * </code>
	 * 
	 * <p>
	 * When setDefaultOperator(AND_OPERATOR) is set, the result will be:
	 * </p>
	 * 
	 * <code>
	 * +(title:term1 body:term1) +(title:term2 body:term2)
	 * </code>
	 * 
	 * <p>
	 * When you pass a boost (title=>5 body=>10) you can get
	 * </p>
	 * 
	 * <code>
	 * +(title:term1^5.0 body:term1^10.0) +(title:term2^5.0 body:term2^10.0)
	 * </code>
	 * 
	 * <p>
	 * In other words, all the query's terms must appear, but it doesn't matter
	 * in what fields they appear.
	 * </p>
	 */
	public MultiFieldQueryParser(String[] fields, Analyzer analyzer, Map boosts) {
		this(fields, analyzer);
		this.boosts = boosts;
	}

	/**
	 * Creates a MultiFieldQueryParser.
	 * 
	 * <p>
	 * It will, when parse(String query) is called, construct a query like this
	 * (assuming the query consists of two terms and you specify the two fields
	 * <code>title</code> and <code>body</code>):
	 * </p>
	 * 
	 * <code>
	 * (title:term1 body:term1) (title:term2 body:term2)
	 * </code>
	 * 
	 * <p>
	 * When setDefaultOperator(AND_OPERATOR) is set, the result will be:
	 * </p>
	 * 
	 * <code>
	 * +(title:term1 body:term1) +(title:term2 body:term2)
	 * </code>
	 * 
	 * <p>
	 * In other words, all the query's terms must appear, but it doesn't matter
	 * in what fields they appear.
	 * </p>
	 */
	public MultiFieldQueryParser(String[] fields, Analyzer analyzer) {
		super(null, analyzer);
		this.fields = fields;
	}

	protected Query getFieldQuery(String field, String queryText, int slop)
			throws ParseException {
		if (field == null) {
			Vector clauses = new Vector();
			for (int i = 0; i < fields.length; i++) {
				Query q = getFieldQuery(fields[i], queryText);
				if (q != null) {
					// If the user passes a map of boosts
					if (boosts != null) {
						// Get the boost from the map and apply them
						Float boost = (Float) boosts.get(fields[i]);
						if (boost != null) {
							q.setBoost(boost.floatValue());
						}
					}
					if (q instanceof PhraseQuery) {
						((PhraseQuery) q).setSlop(slop);
					}
					if (q instanceof MultiPhraseQuery) {
						((MultiPhraseQuery) q).setSlop(slop);
					}
					clauses
							.add(new BooleanClause(q,
									BooleanClause.Occur.SHOULD));
				}
			}
			if (clauses.size() == 0) // happens for stopwords
				return null;
			return getBooleanQuery(clauses, true);
		}
		return super.getFieldQuery(field, queryText);
	}

	protected Query getFieldQuery(String field, String queryText)
			throws ParseException {
		return getFieldQuery(field, queryText, 0);
	}

	protected Query getFuzzyQuery(String field, String termStr,
			float minSimilarity) throws ParseException {
		if (field == null) {
			Vector clauses = new Vector();
			for (int i = 0; i < fields.length; i++) {
				clauses.add(new BooleanClause(getFuzzyQuery(fields[i], termStr,
						minSimilarity), BooleanClause.Occur.SHOULD));
			}
			return getBooleanQuery(clauses, true);
		}
		return super.getFuzzyQuery(field, termStr, minSimilarity);
	}

	protected Query getPrefixQuery(String field, String termStr)
			throws ParseException {
		if (field == null) {
			Vector clauses = new Vector();
			for (int i = 0; i < fields.length; i++) {
				clauses.add(new BooleanClause(
						getPrefixQuery(fields[i], termStr),
						BooleanClause.Occur.SHOULD));
			}
			return getBooleanQuery(clauses, true);
		}
		return super.getPrefixQuery(field, termStr);
	}

	protected Query getWildcardQuery(String field, String termStr)
			throws ParseException {
		if (field == null) {
			Vector clauses = new Vector();
			for (int i = 0; i < fields.length; i++) {
				clauses.add(new BooleanClause(getWildcardQuery(fields[i],
						termStr), BooleanClause.Occur.SHOULD));
			}
			return getBooleanQuery(clauses, true);
		}
		return super.getWildcardQuery(field, termStr);
	}

	protected Query getRangeQuery(String field, String part1, String part2,
			boolean inclusive) throws ParseException {
		if (field == null) {
			Vector clauses = new Vector();
			for (int i = 0; i < fields.length; i++) {
				clauses.add(new BooleanClause(getRangeQuery(fields[i], part1,
						part2, inclusive), BooleanClause.Occur.SHOULD));
			}
			return getBooleanQuery(clauses, true);
		}
		return super.getRangeQuery(field, part1, part2, inclusive);
	}

	/**
	 * Parses a query which searches on the fields specified.
	 * <p>
	 * If x fields are specified, this effectively constructs:
	 * 
	 * <pre>
	 * <code>
	 * (field1:query1) (field2:query2) (field3:query3)...(fieldx:queryx)
	 * </code>
	 * </pre>
	 * 
	 * @param queries
	 *            Queries strings to parse
	 * @param fields
	 *            Fields to search on
	 * @param analyzer
	 *            Analyzer to use
	 * @throws ParseException
	 *             if query parsing fails
	 * @throws IllegalArgumentException
	 *             if the length of the queries array differs from the length of
	 *             the fields array
	 */
	public static Query parse(String[] queries, String[] fields,
			Analyzer analyzer) throws ParseException {
		if (queries.length != fields.length)
			throw new IllegalArgumentException(
					"queries.length != fields.length");
		BooleanQuery bQuery = new BooleanQuery();
		for (int i = 0; i < fields.length; i++) {
			QueryParser qp = new QueryParser(fields[i], analyzer);
			Query q = qp.parse(queries[i]);
			if (q != null && // q never null, just being defensive
					(!(q instanceof BooleanQuery) || ((BooleanQuery) q)
							.getClauses().length > 0)) {
				bQuery.add(q, BooleanClause.Occur.SHOULD);
			}
		}
		return bQuery;
	}

	/**
	 * Parses a query, searching on the fields specified. Use this if you need
	 * to specify certain fields as required, and others as prohibited.
	 * <p>
	 * 
	 * <pre>
	 * Usage:
	 * <code>
	 * String[] fields = { &quot;filename&quot;, &quot;contents&quot;, &quot;description&quot; };
	 * BooleanClause.Occur[] flags = { BooleanClause.Occur.SHOULD,
	 * 		BooleanClause.Occur.MUST, BooleanClause.Occur.MUST_NOT };
	 * MultiFieldQueryParser.parse(&quot;query&quot;, fields, flags, analyzer);
	 * </code>
	 * </pre>
	 * 
	 * <p>
	 * The code above would construct a query:
	 * 
	 * <pre>
	 * <code>
	 * (filename:query) +(contents:query) -(description:query)
	 * </code>
	 * </pre>
	 * 
	 * @param query
	 *            Query string to parse
	 * @param fields
	 *            Fields to search on
	 * @param flags
	 *            Flags describing the fields
	 * @param analyzer
	 *            Analyzer to use
	 * @throws ParseException
	 *             if query parsing fails
	 * @throws IllegalArgumentException
	 *             if the length of the fields array differs from the length of
	 *             the flags array
	 */
	public static Query parse(String query, String[] fields,
			BooleanClause.Occur[] flags, Analyzer analyzer)
			throws ParseException {
		if (fields.length != flags.length)
			throw new IllegalArgumentException("fields.length != flags.length");
		BooleanQuery bQuery = new BooleanQuery();
		for (int i = 0; i < fields.length; i++) {
			QueryParser qp = new QueryParser(fields[i], analyzer);
			Query q = qp.parse(query);
			if (q != null && // q never null, just being defensive
					(!(q instanceof BooleanQuery) || ((BooleanQuery) q)
							.getClauses().length > 0)) {
				bQuery.add(q, flags[i]);
			}
		}
		return bQuery;
	}

	/**
	 * Parses a query, searching on the fields specified. Use this if you need
	 * to specify certain fields as required, and others as prohibited.
	 * <p>
	 * 
	 * <pre>
	 * Usage:
	 * <code>
	 * String[] query = { &quot;query1&quot;, &quot;query2&quot;, &quot;query3&quot; };
	 * String[] fields = { &quot;filename&quot;, &quot;contents&quot;, &quot;description&quot; };
	 * BooleanClause.Occur[] flags = { BooleanClause.Occur.SHOULD,
	 * 		BooleanClause.Occur.MUST, BooleanClause.Occur.MUST_NOT };
	 * MultiFieldQueryParser.parse(query, fields, flags, analyzer);
	 * </code>
	 * </pre>
	 * 
	 * <p>
	 * The code above would construct a query:
	 * 
	 * <pre>
	 * <code>
	 * (filename:query1) +(contents:query2) -(description:query3)
	 * </code>
	 * </pre>
	 * 
	 * @param queries
	 *            Queries string to parse
	 * @param fields
	 *            Fields to search on
	 * @param flags
	 *            Flags describing the fields
	 * @param analyzer
	 *            Analyzer to use
	 * @throws ParseException
	 *             if query parsing fails
	 * @throws IllegalArgumentException
	 *             if the length of the queries, fields, and flags array differ
	 */
	public static Query parse(String[] queries, String[] fields,
			BooleanClause.Occur[] flags, Analyzer analyzer)
			throws ParseException {
		if (!(queries.length == fields.length && queries.length == flags.length))
			throw new IllegalArgumentException(
					"queries, fields, and flags array have have different length");
		BooleanQuery bQuery = new BooleanQuery();
		for (int i = 0; i < fields.length; i++) {
			QueryParser qp = new QueryParser(fields[i], analyzer);
			Query q = qp.parse(queries[i]);
			if (q != null && // q never null, just being defensive
					(!(q instanceof BooleanQuery) || ((BooleanQuery) q)
							.getClauses().length > 0)) {
				bQuery.add(q, flags[i]);
			}
		}
		return bQuery;
	}

}
